package interpreter

import (
	"fmt"
	"jsengine/ast"
	"jsengine/lexer"
	"jsengine/parser"
	"math"
	"strconv"
	"strings"
)

// 定义单例对象，以避免重复创建
var (
	NULL      = &Null{}
	UNDEFINED = &Undefined{}
	TRUE      = &Boolean{Value: true}
	FALSE     = &Boolean{Value: false}
)

// Evaluator 表示JS引擎的解释器
type Evaluator struct {
	env         *Environment
	builtins    map[string]*Builtin
	currentNode ast.Node // 保存当前正在评估的节点
}

// New 创建一个新的解释器
func New() *Evaluator {
	e := &Evaluator{
		env:      NewEnvironment(),
		builtins: make(map[string]*Builtin),
	}
	e.registerBuiltins()
	return e
}

// Eval 解释执行AST
func (e *Evaluator) Eval(node ast.Node) Object {
	// 保存当前处理的节点，用于前缀和后缀运算符
	prevNode := e.currentNode
	e.currentNode = node

	var result Object

	switch node := node.(type) {
	case *ast.Program:
		result = e.evalProgram(node)

	case *ast.ExpressionStatement:
		result = e.Eval(node.Expression)

	case *ast.IntegerLiteral:
		result = &Integer{Value: node.Value}

	case *ast.FloatLiteral:
		result = &Float{Value: node.Value}

	case *ast.StringLiteral:
		result = &String{Value: node.Value}

	case *ast.TemplateLiteral:
		result = e.evalTemplateLiteral(node)

	case *ast.BooleanLiteral:
		result = nativeBoolToBooleanObject(node.Value)

	case *ast.NullLiteral:
		result = NULL

	case *ast.UndefinedLiteral:
		result = UNDEFINED

	case *ast.PrefixExpression:
		// 特殊处理前缀自增自减
		if node.Operator == "++" || node.Operator == "--" {
			// 检查是否是标识符
			if identNode, ok := node.Right.(*ast.Identifier); ok {
				val, ok := e.env.Get(identNode.Value)
				if !ok {
					return newError("未定义的变量: %s", identNode.Value)
				}

				var newVal Object
				switch val.Type() {
				case INTEGER_OBJ:
					intVal := val.(*Integer).Value
					if node.Operator == "++" {
						newVal = &Integer{Value: intVal + 1}
					} else { // "--"
						newVal = &Integer{Value: intVal - 1}
					}
				case FLOAT_OBJ:
					floatVal := val.(*Float).Value
					if node.Operator == "++" {
						newVal = &Float{Value: floatVal + 1.0}
					} else { // "--"
						newVal = &Float{Value: floatVal - 1.0}
					}
				default:
					return newError("无法对类型 %s 执行 %s 操作", val.Type(), node.Operator)
					break
				}

				// 更新变量值
				e.env.Set(identNode.Value, newVal)
				return newVal
			}
		}

		// 其他前缀表达式的常规处理
		right := e.Eval(node.Right)
		if isError(right) {
			return right
		}
		return e.evalPrefixExpression(node.Operator, right)

	case *ast.PostfixExpression:
		left := e.Eval(node.Left)
		if isError(left) {
			return left
		}
		return e.evalPostfixExpression(node.Operator, left, node.Left)

	case *ast.InfixExpression:
		// 处理 && 和 || 逻辑运算符的短路求值
		if node.Operator == "&&" {
			left := e.Eval(node.Left)
			if isError(left) {
				return left
			}
			if !isTruthy(left) {
				return left
			}
			right := e.Eval(node.Right)
			if isError(right) {
				return right
			}
			return right
		}
		if node.Operator == "||" {
			left := e.Eval(node.Left)
			if isError(left) {
				return left
			}
			if isTruthy(left) {
				return left
			}
			right := e.Eval(node.Right)
			if isError(right) {
				return right
			}
			return right
		}

		left := e.Eval(node.Left)
		if isError(left) {
			return left
		}

		right := e.Eval(node.Right)
		if isError(right) {
			return right
		}

		return e.evalInfixExpression(node.Operator, left, right)

	case *ast.BlockStatement:
		return e.evalBlockStatement(node)

	case *ast.IfExpression:
		return e.evalIfExpression(node)

	case *ast.ReturnStatement:
		val := e.Eval(node.ReturnValue)
		if isError(val) {
			return val
		}
		return &ReturnValue{Value: val}

	case *ast.LetStatement:
		val := e.Eval(node.Value)
		if isError(val) {
			result = val
			break
		}
		e.env.Set(node.Name.Value, val)
		result = val

	case *ast.VarStatement:
		val := e.Eval(node.Value)
		if isError(val) {
			result = val
			break
		}
		e.env.Set(node.Name.Value, val)
		result = val

	case *ast.ConstStatement:
		val := e.Eval(node.Value)
		if isError(val) {
			result = val
			break
		}
		e.env.SetConst(node.Name.Value, val)
		result = val

	case *ast.Identifier:
		result = e.evalIdentifier(node)

	case *ast.FunctionLiteral:
		params := node.Parameters
		body := node.Body
		name := node.Name
		result = &Function{Parameters: params, Env: e.env, Body: body, Name: name}

	case *ast.ArrowFunctionLiteral:
		params := node.Parameters
		body := node.Body

		// 如果body不是块语句，我们需要创建一个包含return语句的块语句
		var blockBody *ast.BlockStatement
		if blockStmt, ok := body.(*ast.BlockStatement); ok {
			blockBody = blockStmt
		} else {
			// 创建一个新的块语句，其中包含一条return语句
			returnStmt := &ast.ReturnStatement{
				Token:       lexer.Token{Type: lexer.RETURN, Literal: "return"},
				ReturnValue: body.(ast.Expression),
			}
			blockBody = &ast.BlockStatement{
				Token:      lexer.Token{Type: lexer.LBRACE, Literal: "{"},
				Statements: []ast.Statement{returnStmt},
			}
		}

		result = &Function{Parameters: params, Env: e.env, Body: blockBody, IsArrow: true}

	case *ast.FunctionStatement:
		params := node.Parameters
		body := node.Body
		fn := &Function{Parameters: params, Body: body, Env: e.env, Name: node.Name.Value}
		e.env.Set(node.Name.Value, fn)
		return fn

	case *ast.CallExpression:
		result = e.evalCallExpression(node)

	case *ast.ArrayLiteral:
		elements := e.evalExpressions(node.Elements)
		if len(elements) == 1 && isError(elements[0]) {
			result = elements[0]
			break
		}
		result = &Array{Elements: elements, Methods: make(map[string]Object)}

	case *ast.IndexExpression:
		left := e.Eval(node.Left)
		if isError(left) {
			result = left
			break
		}
		index := e.Eval(node.Index)
		if isError(index) {
			result = index
			break
		}
		result = e.evalIndexExpression(left, index)

	case *ast.PropertyExpression:
		object := e.Eval(node.Object)
		if isError(object) {
			result = object
			break
		}

		var propName string
		// 判断属性是否是标识符
		if propIdent, ok := node.Property.(*ast.Identifier); ok {
			propName = propIdent.Value
		} else {
			// 非标识符属性，计算表达式
			propObj := e.Eval(node.Property)
			if isError(propObj) {
				result = propObj
				break
			}
			propName = propObj.Inspect()
		}

		result = e.evalPropertyExpression(object, propName)

	case *ast.AssignExpression:
		result = e.evalAssignExpression(node)

	case *ast.CompoundAssignExpression:
		result = e.evalCompoundAssignExpression(node)

	case *ast.ObjectLiteral:
		result = e.evalObjectLiteral(node)

	case *ast.ConditionalExpression:
		result = e.evalConditionalExpression(node)

	case *ast.ForLoopStatement:
		result = e.evalForLoopStatement(node)

	case *ast.ForInLoopStatement:
		result = e.evalForInLoopStatement(node)

	case *ast.ForOfLoopStatement:
		result = e.evalForOfLoopStatement(node)

	case *ast.WhileLoopStatement:
		result = e.evalWhileLoopStatement(node)

	case *ast.BreakStatement:
		result = e.evalBreakStatement()

	case *ast.ContinueStatement:
		result = e.evalContinueStatement()

	case *ast.ClassDeclaration:
		result = e.evalClassDeclaration(node)

	case *ast.ClassExpression:
		result = e.evalClassExpression(node)

	case *ast.NewExpression:
		result = e.evalNewExpression(node)

	case *ast.ThisExpression:
		result = e.evalThisExpression()

	case *ast.SuperExpression:
		result = e.evalSuperExpression(node)

	case *ast.TryStatement:
		result = e.evalTryStatement(node)

	case *ast.ThrowStatement:
		result = e.evalThrowStatement(node)

	case *ast.SwitchStatement:
		result = e.evalSwitchStatement(node)

	default:
		// 其他情况保持原样
		result = nil
	}

	e.currentNode = prevNode
	return result
}

// evalProgram 解释执行程序
func (e *Evaluator) evalProgram(program *ast.Program) Object {
	var result Object

	for _, statement := range program.Statements {
		result = e.Eval(statement)

		switch result := result.(type) {
		case *ReturnValue:
			return result.Value
		case *Error:
			return result
		}
	}

	if result == nil {
		return UNDEFINED
	}

	return result
}

// evalBlockStatement 解释执行块语句
func (e *Evaluator) evalBlockStatement(block *ast.BlockStatement) Object {
	var result Object

	for _, statement := range block.Statements {
		result = e.Eval(statement)

		if result != nil {
			rt := result.Type()
			if rt == RETURN_VALUE_OBJ || rt == ERROR_OBJ || rt == BREAK_OBJ || rt == CONTINUE_OBJ {
				return result
			}
		}
	}

	if result == nil {
		return UNDEFINED
	}

	return result
}

// evalPrefixExpression 解释执行前缀表达式
func (e *Evaluator) evalPrefixExpression(operator string, right Object) Object {
	// 将当前节点转换为前缀表达式节点
	prefixExpr, isPrefixExpr := e.currentNode.(*ast.PrefixExpression)

	// 处理自增自减操作
	if operator == "++" || operator == "--" {
		if isPrefixExpr {
			// 检查右操作数是否为标识符
			if identNode, ok := prefixExpr.Right.(*ast.Identifier); ok {
				// 这里right已经是求值后的对象，我们使用AST节点获取标识符的名称
				val, ok := e.env.Get(identNode.Value)
				if !ok {
					return newError("未定义的变量: %s", identNode.Value)
				}

				var newVal Object
				// 计算新值
				switch val.Type() {
				case INTEGER_OBJ:
					intVal := val.(*Integer).Value
					if operator == "++" {
						newVal = &Integer{Value: intVal + 1}
					} else { // operator == "--"
						newVal = &Integer{Value: intVal - 1}
					}
				case FLOAT_OBJ:
					floatVal := val.(*Float).Value
					if operator == "++" {
						newVal = &Float{Value: floatVal + 1.0}
					} else { // operator == "--"
						newVal = &Float{Value: floatVal - 1.0}
					}
				default:
					return newError("无法对类型 %s 执行 %s 操作", val.Type(), operator)
				}

				// 更新变量值
				e.env.Set(identNode.Value, newVal)
				return newVal
			}
		}

		// 如果不是作用于标识符的自增自减，则直接处理值
		switch right.Type() {
		case INTEGER_OBJ:
			intVal := right.(*Integer).Value
			if operator == "++" {
				return &Integer{Value: intVal + 1}
			} else { // operator == "--"
				return &Integer{Value: intVal - 1}
			}
		case FLOAT_OBJ:
			floatVal := right.(*Float).Value
			if operator == "++" {
				return &Float{Value: floatVal + 1.0}
			} else { // operator == "--"
				return &Float{Value: floatVal - 1.0}
			}
		default:
			return newError("无法对类型 %s 执行 %s 操作", right.Type(), operator)
		}
	}

	// 对于其他前缀运算符，使用原有的处理逻辑
	switch operator {
	case "!":
		return e.evalBangOperatorExpression(right)
	case "-":
		return e.evalMinusPrefixOperatorExpression(right)
	default:
		return newError("未知运算符: %s%s", operator, right.Type())
	}
}

// evalBangOperatorExpression 解释执行 ! 运算符
func (e *Evaluator) evalBangOperatorExpression(right Object) Object {
	switch right {
	case TRUE:
		return FALSE
	case FALSE:
		return TRUE
	case NULL:
		return TRUE
	case UNDEFINED:
		return TRUE
	default:
		return FALSE
	}
}

// evalMinusPrefixOperatorExpression 解释执行 - 前缀运算符
func (e *Evaluator) evalMinusPrefixOperatorExpression(right Object) Object {
	switch right.Type() {
	case INTEGER_OBJ:
		value := right.(*Integer).Value
		return &Integer{Value: -value}
	case FLOAT_OBJ:
		value := right.(*Float).Value
		return &Float{Value: -value}
	default:
		return newError("未知运算符: -%s", right.Type())
	}
}

// evalIncrementPrefixOperatorExpression 解释执行 ++ 前缀运算符
func (e *Evaluator) evalIncrementPrefixOperatorExpression(right Object) Object {
	// 直接处理数值类型
	switch right.Type() {
	case INTEGER_OBJ:
		intVal := right.(*Integer).Value
		return &Integer{Value: intVal + 1}
	case FLOAT_OBJ:
		floatVal := right.(*Float).Value
		return &Float{Value: floatVal + 1.0}
	default:
		return newError("无法对类型 %s 执行 ++ 操作", right.Type())
	}
}

// evalDecrementPrefixOperatorExpression 解释执行 -- 前缀运算符
func (e *Evaluator) evalDecrementPrefixOperatorExpression(right Object) Object {
	// 直接处理数值类型
	switch right.Type() {
	case INTEGER_OBJ:
		intVal := right.(*Integer).Value
		return &Integer{Value: intVal - 1}
	case FLOAT_OBJ:
		floatVal := right.(*Float).Value
		return &Float{Value: floatVal - 1.0}
	default:
		return newError("无法对类型 %s 执行 -- 操作", right.Type())
	}
}

// evalInfixExpression 解释执行中缀表达式
func (e *Evaluator) evalInfixExpression(
	operator string,
	left, right Object,
) Object {
	switch {
	case left.Type() == INTEGER_OBJ && right.Type() == INTEGER_OBJ:
		return e.evalIntegerInfixExpression(operator, left, right)
	case left.Type() == FLOAT_OBJ || right.Type() == FLOAT_OBJ:
		return e.evalFloatInfixExpression(operator, left, right)
	case left.Type() == STRING_OBJ && right.Type() == STRING_OBJ:
		return e.evalStringInfixExpression(operator, left, right)
	case left.Type() == STRING_OBJ && operator == "+":
		return &String{Value: left.(*String).Value + right.Inspect()}
	case right.Type() == STRING_OBJ && operator == "+":
		return &String{Value: left.Inspect() + right.(*String).Value}
	case operator == "==":
		return nativeBoolToBooleanObject(left == right)
	case operator == "!=":
		return nativeBoolToBooleanObject(left != right)
	case operator == "&&":
		return e.evalLogicalAndExpression(left, right)
	case operator == "||":
		return e.evalLogicalOrExpression(left, right)
	case left.Type() != right.Type():
		return newError("类型不匹配: %s %s %s",
			left.Type(), operator, right.Type())
	default:
		return newError("未知运算符: %s %s %s",
			left.Type(), operator, right.Type())
	}
}

// evalIntegerInfixExpression 解释执行整数中缀表达式
func (e *Evaluator) evalIntegerInfixExpression(
	operator string,
	left, right Object,
) Object {
	leftVal := left.(*Integer).Value
	rightVal := right.(*Integer).Value

	switch operator {
	case "+":
		return &Integer{Value: leftVal + rightVal}
	case "-":
		return &Integer{Value: leftVal - rightVal}
	case "*":
		return &Integer{Value: leftVal * rightVal}
	case "/":
		if rightVal == 0 {
			return newError("除零错误")
		}
		// JS中整数除法可能产生浮点数
		if leftVal%rightVal == 0 {
			return &Integer{Value: leftVal / rightVal}
		}
		return &Float{Value: float64(leftVal) / float64(rightVal)}
	case "%":
		if rightVal == 0 {
			return newError("除零错误")
		}
		return &Integer{Value: leftVal % rightVal}
	case "<":
		return nativeBoolToBooleanObject(leftVal < rightVal)
	case ">":
		return nativeBoolToBooleanObject(leftVal > rightVal)
	case "<=":
		return nativeBoolToBooleanObject(leftVal <= rightVal)
	case ">=":
		return nativeBoolToBooleanObject(leftVal >= rightVal)
	case "==":
		return nativeBoolToBooleanObject(leftVal == rightVal)
	case "!=":
		return nativeBoolToBooleanObject(leftVal != rightVal)
	default:
		return newError("未知运算符: %s %s %s",
			left.Type(), operator, right.Type())
	}
}

// evalFloatInfixExpression 解释执行浮点数中缀表达式
func (e *Evaluator) evalFloatInfixExpression(
	operator string,
	left, right Object,
) Object {
	var leftVal, rightVal float64

	switch left.Type() {
	case INTEGER_OBJ:
		leftVal = float64(left.(*Integer).Value)
	case FLOAT_OBJ:
		leftVal = left.(*Float).Value
	}

	switch right.Type() {
	case INTEGER_OBJ:
		rightVal = float64(right.(*Integer).Value)
	case FLOAT_OBJ:
		rightVal = right.(*Float).Value
	}

	switch operator {
	case "+":
		return &Float{Value: leftVal + rightVal}
	case "-":
		return &Float{Value: leftVal - rightVal}
	case "*":
		return &Float{Value: leftVal * rightVal}
	case "/":
		if rightVal == 0 {
			return newError("除零错误")
		}
		return &Float{Value: leftVal / rightVal}
	case "%":
		if rightVal == 0 {
			return newError("除零错误")
		}
		return &Float{Value: float64(int64(leftVal) % int64(rightVal))}
	case "<":
		return nativeBoolToBooleanObject(leftVal < rightVal)
	case ">":
		return nativeBoolToBooleanObject(leftVal > rightVal)
	case "<=":
		return nativeBoolToBooleanObject(leftVal <= rightVal)
	case ">=":
		return nativeBoolToBooleanObject(leftVal >= rightVal)
	case "==":
		return nativeBoolToBooleanObject(leftVal == rightVal)
	case "!=":
		return nativeBoolToBooleanObject(leftVal != rightVal)
	default:
		return newError("未知运算符: %s %s %s",
			left.Type(), operator, right.Type())
	}
}

// evalStringInfixExpression 解释执行字符串中缀表达式
func (e *Evaluator) evalStringInfixExpression(
	operator string,
	left, right Object,
) Object {
	leftVal := left.(*String).Value
	rightVal := right.(*String).Value

	switch operator {
	case "+":
		return &String{Value: leftVal + rightVal}
	case "==":
		return nativeBoolToBooleanObject(leftVal == rightVal)
	case "!=":
		return nativeBoolToBooleanObject(leftVal != rightVal)
	default:
		return newError("未知运算符: %s %s %s",
			left.Type(), operator, right.Type())
	}
}

// evalLogicalAndExpression 解释执行逻辑AND表达式
func (e *Evaluator) evalLogicalAndExpression(left, right Object) Object {
	if isTruthy(left) {
		return right
	}
	return left
}

// evalLogicalOrExpression 解释执行逻辑OR表达式
func (e *Evaluator) evalLogicalOrExpression(left, right Object) Object {
	if isTruthy(left) {
		return left
	}
	return right
}

// evalIfExpression 解释执行if表达式
func (e *Evaluator) evalIfExpression(ie *ast.IfExpression) Object {
	condition := e.Eval(ie.Condition)
	if isError(condition) {
		return condition
	}

	if isTruthy(condition) {
		return e.Eval(ie.Consequence)
	} else if ie.Alternative != nil {
		return e.Eval(ie.Alternative)
	} else {
		return UNDEFINED
	}
}

// evalIdentifier 解释执行标识符
func (e *Evaluator) evalIdentifier(node *ast.Identifier) Object {
	if val, ok := e.env.Get(node.Value); ok {
		return val
	}

	if builtin, ok := e.builtins[node.Value]; ok {
		return builtin
	}

	return newError("未定义的变量: %s", node.Value)
}

// evalAssignExpression 解释执行赋值表达式
func (e *Evaluator) evalAssignExpression(node *ast.AssignExpression) Object {
	val := e.Eval(node.Value)
	if isError(val) {
		return val
	}

	switch left := node.Left.(type) {
	case *ast.Identifier:
		if _, ok := e.env.Get(left.Value); !ok {
			return newError("未定义的变量: %s", left.Value)
		}
		e.env.Set(left.Value, val)
		return val

	case *ast.IndexExpression:
		obj := e.Eval(left.Left)
		if isError(obj) {
			return obj
		}

		index := e.Eval(left.Index)
		if isError(index) {
			return index
		}

		return e.evalIndexAssignExpression(obj, index, val)

	case *ast.PropertyExpression:
		obj := e.Eval(left.Object)
		if isError(obj) {
			return obj
		}

		if prop, ok := left.Property.(*ast.Identifier); ok {
			return e.evalPropertyAssignExpression(obj, prop.Value, val)
		}

		return newError("无效的属性赋值: %s", left.Property.String())

	default:
		return newError("无效的赋值目标: %s", node.Left.String())
	}
}

// evalExpressions 解释执行表达式列表
func (e *Evaluator) evalExpressions(exps []ast.Expression) []Object {
	var result []Object

	for _, exp := range exps {
		evaluated := e.Eval(exp)
		if isError(evaluated) {
			return []Object{evaluated}
		}
		result = append(result, evaluated)
	}

	return result
}

// evalCallExpression 解释执行函数调用表达式
func (e *Evaluator) evalCallExpression(node *ast.CallExpression) Object {
	// 检查是否调用的是方法 (obj.method())
	if propExpr, ok := node.Function.(*ast.PropertyExpression); ok {
		obj := e.Eval(propExpr.Object)
		if isError(obj) {
			return obj
		}

		// 获取属性名
		var propName string
		switch prop := propExpr.Property.(type) {
		case *ast.Identifier:
			propName = prop.Value
		default:
			// 计算属性名称
			propObj := e.Eval(propExpr.Property)
			if isError(propObj) {
				return propObj
			}
			propName = propObj.Inspect()
		}

		// 检查是否可以通过ObjectWithMethods接口获取方法
		if methodProvider, ok := obj.(ObjectWithMethods); ok {

			if method, ok := methodProvider.GetMethod(propName); ok {

				// 评估参数
				args := e.evalExpressions(node.Arguments)
				if len(args) == 1 && isError(args[0]) {
					return args[0]
				}

				// 处理方法调用
				switch fn := method.(type) {
				case *Function:

					// 创建扩展的环境，并设置this为对象
					extendedEnv := extendFunctionEnv(fn, args)
					extendedEnv.Set("this", obj) // 设置this指向调用对象

					// 临时切换环境
					oldEnv := e.env
					e.env = extendedEnv
					defer func() { e.env = oldEnv }()

					// 执行函数体
					evaluated := e.Eval(fn.Body)
					return unwrapReturnValue(evaluated)
				case *Builtin:

					// 内置方法，将对象作为第一个参数传递
					extendedArgs := append([]Object{obj}, args...)
					return fn.Fn(extendedArgs...)
				default:

					// 如果不是函数，直接返回属性值
					return method
				}
			} else {

			}
		} else {

		}

		// 如果通过接口无法获取方法，则尝试通过普通属性访问
		method := e.evalPropertyExpression(obj, propName)
		if isError(method) {
			return method
		}

		// 评估参数
		args := e.evalExpressions(node.Arguments)
		if len(args) == 1 && isError(args[0]) {
			return args[0]
		}

		// 针对不同类型的方法调用
		switch fn := method.(type) {
		case *Function:

			// 创建扩展的环境，并设置this为对象
			extendedEnv := extendFunctionEnv(fn, args)
			extendedEnv.Set("this", obj) // 设置this指向调用对象

			// 临时切换环境
			oldEnv := e.env
			e.env = extendedEnv
			defer func() { e.env = oldEnv }()

			// 执行函数体
			evaluated := e.Eval(fn.Body)
			return unwrapReturnValue(evaluated)
		case *Builtin:

			// 内置方法，将对象作为第一个参数传递
			extendedArgs := append([]Object{obj}, args...)
			return fn.Fn(extendedArgs...)
		default:

			// 如果不是函数，直接返回属性值
			return newError("不是函数: %s", method.Type())
		}
	} else {

	}

	// 常规函数调用
	function := e.Eval(node.Function)
	if isError(function) {
		return function
	}

	args := e.evalExpressions(node.Arguments)
	if len(args) == 1 && isError(args[0]) {
		return args[0]
	}

	return e.applyFunction(function, args)
}

// applyFunction 解释执行函数调用
func (e *Evaluator) applyFunction(fn Object, args []Object) Object {

	switch fn := fn.(type) {
	case *Function:
		extendedEnv := extendFunctionEnv(fn, args)

		// 检查是否已经设置了this
		if _, ok := extendedEnv.Get("this"); !ok {
			// 默认设置全局对象为this（非方法调用的情况）
			extendedEnv.Set("this", NewHash())
		}

		oldEnv := e.env
		e.env = extendedEnv
		defer func() { e.env = oldEnv }()

		evaluated := e.Eval(fn.Body)
		return unwrapReturnValue(evaluated)
	case *Builtin:
		return fn.Fn(args...)
	case *Class:
		// 如果是在new表达式中，应该由evalNewExpression处理，
		// 这里只处理直接调用类(作为函数调用)的情况
		if fn.Constructor != nil {
			// 创建新实例
			instance := &ClassInstance{
				Class:      fn,
				Properties: make(map[HashKey]HashPair),
			}

			// 调用构造函数
			constructorEnv := extendFunctionEnv(fn.Constructor, args)
			constructorEnv.Set("this", instance)

			oldEnv := e.env
			e.env = constructorEnv
			e.Eval(fn.Constructor.Body)
			e.env = oldEnv

			return instance
		}
		return newError("类 %s 没有定义构造函数", fn.Name)
	case *SuperReference:
		// 处理super()调用，调用父类构造函数
		if fn.Super == nil || fn.Super.Prototype == nil {
			return newError("无法调用super()，当前类没有父类")
		}

		// 获取父类
		var parentClass *Class

		// 从原型链中找到父类
		prototype := fn.Instance.Class.Prototype
		if prototype != nil && prototype.Prototype != nil {
			// 查找父类引用
			parentClassKey := &String{Value: "__parent_class__"}
			parentClassHashKey := parentClassKey.HashKey()

			if pair, ok := prototype.Pairs[parentClassHashKey]; ok {
				if superClass, ok := pair.Value.(*Class); ok {
					parentClass = superClass
				}
			}
		}

		// 如果没找到，尝试通过环境查找
		if parentClass == nil {
			// 尝试从环境中查找类
			for _, name := range []string{"Animal", "Object"} { // 尝试常见的基类名称
				obj, ok := e.env.Get(name)
				if ok {
					if cls, ok := obj.(*Class); ok {
						parentClass = cls
						break
					}
				}
			}
		}

		// 获取当前this实例
		thisInstance := fn.Instance

		// 如果有父类，正确执行父类构造函数
		if parentClass != nil && parentClass.Constructor != nil {
			// 创建环境，传递参数
			constructorEnv := extendFunctionEnv(parentClass.Constructor, args)
			constructorEnv.Set("this", thisInstance) // 设置this为当前实例

			// 执行父类构造函数
			oldEnv := e.env
			e.env = constructorEnv

			// 记录构造函数调用前的属性数量
			oldPropsCount := len(thisInstance.Properties)

			// 执行父类构造函数
			e.Eval(parentClass.Constructor.Body)

			// 检查构造函数是否成功设置了属性
			if len(thisInstance.Properties) == oldPropsCount {
				// 如果没有设置任何属性，说明父类构造函数可能没有正确设置属性
				// 手动设置参数到属性
				paramCount := len(parentClass.Constructor.Parameters)
				for i := 0; i < paramCount && i < len(args); i++ {
					paramName := parentClass.Constructor.Parameters[i].Value
					propKey := &String{Value: paramName}
					hashKey := propKey.HashKey()
					thisInstance.Properties[hashKey] = HashPair{Key: propKey, Value: args[i]}
				}
			}

			e.env = oldEnv

			return thisInstance
		}

		return newError("无法执行父类构造函数")
	default:
		return newError("不是函数: %s", fn.Type())
	}
}

// extendFunctionEnv 扩展函数环境
func extendFunctionEnv(fn *Function, args []Object) *Environment {
	env := NewEnclosedEnvironment(fn.Env)

	for paramIdx, param := range fn.Parameters {
		if paramIdx < len(args) {
			// 对箭头函数特殊处理，确保参数值正确设置
			if fn.IsArrow {
				// 深度绑定参数，确保在箭头函数中可以访问
				env.SetConst(param.Value, args[paramIdx]) // 使用SetConst以防止重新赋值
			} else {
				env.Set(param.Value, args[paramIdx])
			}
		} else {
			env.Set(param.Value, UNDEFINED)
		}
	}

	return env
}

// unwrapReturnValue 展开返回值
func unwrapReturnValue(obj Object) Object {
	if returnValue, ok := obj.(*ReturnValue); ok {
		return returnValue.Value
	}
	return obj
}

// evalIndexExpression 解释执行索引表达式
func (e *Evaluator) evalIndexExpression(left, index Object) Object {
	switch {
	case left.Type() == ARRAY_OBJ && index.Type() == INTEGER_OBJ:
		return e.evalArrayIndexExpression(left, index)
	case left.Type() == OBJECT_OBJ:
		return e.evalHashIndexExpression(left, index)
	default:
		return newError("运算符未定义: %s[%s]", left.Type(), index.Type())
	}
}

// evalArrayIndexExpression 解释执行数组索引表达式
func (e *Evaluator) evalArrayIndexExpression(array, index Object) Object {
	arrayObject := array.(*Array)
	idx := index.(*Integer).Value
	max := int64(len(arrayObject.Elements) - 1)

	if idx < 0 || idx > max {
		return UNDEFINED
	}

	return arrayObject.Elements[idx]
}

// evalHashIndexExpression 解释执行哈希索引表达式
func (e *Evaluator) evalHashIndexExpression(hash, index Object) Object {
	hashObject := hash.(*Hash)

	key, ok := index.(Hashable)
	if !ok {
		return newError("不可哈希的类型: %s", index.Type())
	}

	if pair, ok := hashObject.Pairs[key.HashKey()]; ok {
		return pair.Value
	}

	return UNDEFINED
}

// evalIndexAssignExpression 解释执行索引赋值表达式
func (e *Evaluator) evalIndexAssignExpression(obj, index, val Object) Object {
	switch {
	case obj.Type() == ARRAY_OBJ && index.Type() == INTEGER_OBJ:
		arrayObject := obj.(*Array)
		idx := index.(*Integer).Value
		max := int64(len(arrayObject.Elements) - 1)

		if idx < 0 {
			return newError("索引越界: %d", idx)
		}

		// 如果索引超出当前数组长度，扩展数组
		if idx > max {
			for i := max + 1; i <= idx; i++ {
				arrayObject.Elements = append(arrayObject.Elements, UNDEFINED)
			}
		}

		arrayObject.Elements[idx] = val
		return val

	case obj.Type() == OBJECT_OBJ:
		hashObject := obj.(*Hash)

		key, ok := index.(Hashable)
		if !ok {
			return newError("不可哈希的类型: %s", index.Type())
		}

		hashObject.Pairs[key.HashKey()] = HashPair{Key: index, Value: val}
		return val

	default:
		return newError("运算符未定义: %s[%s] = ...", obj.Type(), index.Type())
	}
}

// evalPropertyExpression 解释执行属性访问表达式
func (e *Evaluator) evalPropertyExpression(obj Object, propName string) Object {

	// 先检查是否是ObjectWithMethods接口
	if methodProvider, ok := obj.(ObjectWithMethods); ok {

		if method, ok := methodProvider.GetMethod(propName); ok {

			return method
		} else {

		}
	} else {

	}

	switch o := obj.(type) {
	case *Hash:
		// 首先检查是否是方法
		if method, ok := o.Methods[propName]; ok {
			return method
		}

		// 创建属性名的字符串对象
		propKey := &String{Value: propName}
		hashKey := propKey.HashKey()

		// 查找属性
		if pair, ok := o.Pairs[hashKey]; ok {
			return pair.Value
		}

		// 如果在当前对象中找不到，检查原型链
		if o.Prototype != nil {
			return e.evalPropertyExpression(o.Prototype, propName)
		}

		return UNDEFINED

	case *Array:
		// 特殊处理数组的length属性
		if propName == "length" {
			return &Integer{Value: int64(len(o.Elements))}
		}

		// 检查数组方法
		if method, ok := o.Methods[propName]; ok {
			return method
		}

		return UNDEFINED

	case *ClassInstance:
		// 先查找实例属性
		propKey := &String{Value: propName}
		hashKey := propKey.HashKey()

		if pair, ok := o.Properties[hashKey]; ok {

			return pair.Value
		} else {

		}

		// 检查类的静态方法
		if o.Class != nil {

			if method, ok := o.Class.Methods[propName]; ok {

				return method
			} else {

			}
		}

		// 检查类的原型属性
		if o.Class != nil && o.Class.Prototype != nil {

			// 检查原型中的属性
			if proto := o.Class.Prototype; proto != nil {
				if pair, ok := proto.Pairs[hashKey]; ok {

					return pair.Value
				}

				// 递归检查原型链
				current := proto.Prototype
				for current != nil {
					if pair, ok := current.Pairs[hashKey]; ok {

						return pair.Value
					}
					current = current.Prototype
				}
			}

			// 检查实例方法

			if method, ok := o.Class.Prototype.Methods[propName]; ok {

				return method
			} else {

			}

			// 原型链查找方法
			if o.Class.Prototype.Prototype != nil {

				current := o.Class.Prototype.Prototype
				for current != nil {
					if method, ok := current.Methods[propName]; ok {

						return method
					}
					current = current.Prototype
				}
			}
		}

		return UNDEFINED

	case *Class:
		// 查找静态属性
		if val, ok := o.Properties[propName]; ok {
			return val
		}

		// 查找静态方法
		if method, ok := o.Methods[propName]; ok {
			return method
		}

		return UNDEFINED

	case ObjectWithMethods:
		// 通过接口获取方法
		if method, ok := o.GetMethod(propName); ok {
			return method
		}

		return UNDEFINED

	case *SuperReference:
		// 检查父类原型中的方法
		if method, ok := o.GetMethod(propName); ok {
			return method
		}

		// 如果不是方法，则查找属性
		if o.Super != nil {
			// 创建属性名的字符串对象
			propKey := &String{Value: propName}
			hashKey := propKey.HashKey()

			// 查找属性
			if pair, ok := o.Super.Pairs[hashKey]; ok {
				return pair.Value
			}

			// 继续在原型链上查找
			if o.Super.Prototype != nil {
				return e.evalPropertyExpression(o.Super.Prototype, propName)
			}
		}

		return UNDEFINED

	default:
		return newError("无法获取属性 '%s' 于类型 '%s'", propName, obj.Type())
	}
}

// evalPropertyAssignExpression 解释执行属性赋值表达式
func (e *Evaluator) evalPropertyAssignExpression(obj Object, propName string, val Object) Object {

	switch obj := obj.(type) {
	case *Hash:
		propKey := &String{Value: propName}
		hashKey := propKey.HashKey()

		obj.Pairs[hashKey] = HashPair{Key: propKey, Value: val}
		return val

	case *ClassInstance:

		propKey := &String{Value: propName}
		hashKey := propKey.HashKey()

		obj.Properties[hashKey] = HashPair{Key: propKey, Value: val}
		return val

	default:
		return newError("属性赋值未定义: %s.%s = ...", obj.Type(), propName)
	}
}

// evalObjectLiteral 解释执行对象字面量
func (e *Evaluator) evalObjectLiteral(node *ast.ObjectLiteral) Object {
	pairs := make(map[HashKey]HashPair)
	methods := make(map[string]Object)

	for keyNode, valueNode := range node.Pairs {
		var key Object

		// 处理键节点
		switch k := keyNode.(type) {
		case *ast.StringLiteral:
			// 字符串字面量作为键
			key = &String{Value: k.Value}
		case *ast.Identifier:
			// 标识符作为键
			key = &String{Value: k.Value}
		default:
			// 计算属性
			key = e.Eval(keyNode)
			if isError(key) {
				return key
			}

			// 如果键是undefined或null，转换为字符串
			if key == UNDEFINED {
				key = &String{Value: "undefined"}
			} else if key == NULL {
				key = &String{Value: "null"}
			}
		}

		// 确保键是可哈希的
		hashKey, ok := key.(Hashable)
		if !ok {
			return newError("不可哈希的类型: %s", key.Type())
		}

		// 计算值
		value := e.Eval(valueNode)
		if isError(value) {
			return value
		}

		// 存储键值对
		hashed := hashKey.HashKey()
		pairs[hashed] = HashPair{Key: key, Value: value}

		// 对于函数值，如果键是字符串，则也作为方法保存
		if fn, ok := value.(*Function); ok {
			if strKey, ok := key.(*String); ok {
				methods[strKey.Value] = fn
			}
		}
	}

	// 从环境中获取Object构造函数包装器
	objWrapperObj, _ := e.env.Get("Object")
	if objWrapperObj == nil {
		// 如果Object尚未定义，返回没有原型的对象
		return &Hash{
			Pairs:     pairs,
			Methods:   methods,
			Prototype: nil,
		}
	}

	// 获取Object.prototype
	objWrapper, ok := objWrapperObj.(*Hash)
	if !ok {
		// 如果Object不是预期类型，返回没有原型的对象
		return &Hash{
			Pairs:     pairs,
			Methods:   methods,
			Prototype: nil,
		}
	}

	// 获取原型对象
	protoKey := &String{Value: "prototype"}
	hashKey := protoKey.HashKey()
	protoPair, ok := objWrapper.Pairs[hashKey]
	if !ok {
		// 如果没有找到原型，返回没有原型的对象
		return &Hash{
			Pairs:     pairs,
			Methods:   methods,
			Prototype: nil,
		}
	}

	objectProto, ok := protoPair.Value.(*Hash)
	if !ok {
		// 如果原型不是Hash对象，返回没有原型的对象
		return &Hash{
			Pairs:     pairs,
			Methods:   methods,
			Prototype: nil,
		}
	}

	// 返回带有正确原型链的对象
	return &Hash{
		Pairs:     pairs,
		Methods:   methods,
		Prototype: objectProto,
	}
}

// evalConditionalExpression 解释执行三元条件表达式
func (e *Evaluator) evalConditionalExpression(ce *ast.ConditionalExpression) Object {
	condition := e.Eval(ce.Condition)
	if isError(condition) {
		return condition
	}

	if isTruthy(condition) {
		return e.Eval(ce.Consequence)
	} else {
		return e.Eval(ce.Alternative)
	}
}

// evalForLoopStatement 解释执行for循环语句
func (e *Evaluator) evalForLoopStatement(fl *ast.ForLoopStatement) Object {
	// 直接在原始环境中执行，不创建新环境
	// 这样可以确保循环内的变量修改会影响外部环境

	// 执行初始化语句
	if fl.Init != nil {
		initResult := e.Eval(fl.Init)
		if isError(initResult) {
			return initResult
		}
	}

	var result Object = UNDEFINED

	// 执行循环
	for {
		// 检查条件
		if fl.Condition != nil {
			condition := e.Eval(fl.Condition)
			if isError(condition) {
				return condition
			}

			if !isTruthy(condition) {
				break
			}
		}

		// 执行循环体
		result = e.Eval(fl.Body)
		if isError(result) {
			return result
		}

		// 检查是否有返回值
		if result != nil && result.Type() == RETURN_VALUE_OBJ {
			return result // 保留ReturnValue的包装，让外层函数处理
		}

		// 如果遇到break，跳出循环
		if result != nil && result.Type() == BREAK_OBJ {
			break // 只跳出循环，不立即返回
		}

		// 如果遇到continue，直接执行更新表达式
		if result != nil && result.Type() == CONTINUE_OBJ {
			// 执行更新表达式
			if fl.Update != nil {
				updateResult := e.Eval(fl.Update)
				if isError(updateResult) {
					return updateResult
				}
			}
			continue
		}

		// 执行更新表达式
		if fl.Update != nil {
			updateResult := e.Eval(fl.Update)
			if isError(updateResult) {
				return updateResult
			}
		}
	}

	return UNDEFINED
}

// evalForInLoopStatement 解释执行for...in循环语句
func (e *Evaluator) evalForInLoopStatement(fl *ast.ForInLoopStatement) Object {
	// 创建一个新的环境，以支持循环内的变量作用域
	loopEnv := NewEnclosedEnvironment(e.env)
	oldEnv := e.env
	e.env = loopEnv

	// 解析要迭代的对象
	objToIterate := e.Eval(fl.Object)
	if isError(objToIterate) {
		e.env = oldEnv
		return objToIterate
	}

	// 确保对象可以迭代
	var keys []string

	// 检查对象类型
	switch obj := objToIterate.(type) {
	case *Hash:
		// 从哈希对象中获取所有键名
		for _, pair := range obj.Pairs {
			if s, ok := pair.Key.(*String); ok {
				keys = append(keys, s.Value)
			} else {
				// 非字符串键转换为字符串
				keys = append(keys, pair.Key.Inspect())
			}
		}
	case *Array:
		// 对于数组，键是索引
		for i := 0; i < len(obj.Elements); i++ {
			keys = append(keys, strconv.Itoa(i))
		}
	default:
		// 默认处理为空对象
		e.env = oldEnv
		return NULL
	}

	var result Object = NULL

	// 在循环开始时声明变量（如果需要）
	if fl.HasDeclaration {
		e.env.Set(fl.VarName, NULL)
	}

	// 遍历键并执行循环体
	for _, key := range keys {
		// 设置循环变量
		e.env.Set(fl.VarName, &String{Value: key})

		// 执行循环体
		result = e.Eval(fl.Body)

		// 检查循环控制流
		if isError(result) {
			break
		}

		if _, ok := result.(*Break); ok {
			break
		}

		if _, ok := result.(*Continue); ok {
			continue
		}

		if rv, ok := result.(*ReturnValue); ok {
			e.env = oldEnv
			return rv
		}
	}

	// 恢复原环境
	e.env = oldEnv

	// 如果循环因为break结束，返回NULL而不是BREAK对象
	if _, ok := result.(*Break); ok {
		return NULL
	}

	// 如果循环因为continue结束，返回NULL而不是CONTINUE对象
	if _, ok := result.(*Continue); ok {
		return NULL
	}

	return NULL
}

// evalForOfLoopStatement 解释执行for...of循环语句
func (e *Evaluator) evalForOfLoopStatement(fl *ast.ForOfLoopStatement) Object {
	// 创建一个新的环境，以支持循环内的变量作用域
	loopEnv := NewEnclosedEnvironment(e.env)
	oldEnv := e.env
	e.env = loopEnv

	// 解析要迭代的可迭代对象
	iterableObj := e.Eval(fl.Iterable)
	if isError(iterableObj) {
		e.env = oldEnv
		return iterableObj
	}

	// 确保对象可以迭代
	var elements []Object

	// 检查对象类型
	switch obj := iterableObj.(type) {
	case *Array:
		// 数组直接使用其元素
		elements = obj.Elements
	case *String:
		// 字符串将被拆分为字符
		for _, ch := range obj.Value {
			elements = append(elements, &String{Value: string(ch)})
		}
	default:
		// 默认情况下，尝试获取对象的值进行迭代
		e.env = oldEnv
		return newError("for...of 右侧对象不可迭代: %s", iterableObj.Type())
	}

	var result Object = NULL

	// 在循环开始时声明变量（如果需要）
	if fl.HasDeclaration {
		e.env.Set(fl.VarName, NULL)
	}

	// 遍历元素并执行循环体
	for _, value := range elements {
		// 设置循环变量的值
		e.env.Set(fl.VarName, value)

		// 执行循环体
		result = e.Eval(fl.Body)

		// 检查循环控制流
		if isError(result) {
			break
		}

		if _, ok := result.(*Break); ok {
			break
		}

		if _, ok := result.(*Continue); ok {
			continue
		}

		if rv, ok := result.(*ReturnValue); ok {
			e.env = oldEnv
			return rv
		}
	}

	// 恢复原环境
	e.env = oldEnv

	// 如果循环因为break结束，返回NULL而不是BREAK对象
	if _, ok := result.(*Break); ok {
		return NULL
	}

	// 如果循环因为continue结束，返回NULL而不是CONTINUE对象
	if _, ok := result.(*Continue); ok {
		return NULL
	}

	return NULL
}

// evalWhileLoopStatement 解释执行while循环语句
func (e *Evaluator) evalWhileLoopStatement(wl *ast.WhileLoopStatement) Object {
	// 创建新的作用域环境
	outerEnv := e.env
	loopEnv := NewEnclosedEnvironment(outerEnv)
	e.env = loopEnv

	var result Object = UNDEFINED

	// 执行循环
	for {
		// 检查条件
		condition := e.Eval(wl.Condition)
		if isError(condition) {
			e.env = outerEnv // 恢复环境
			return condition
		}

		if !isTruthy(condition) {
			break
		}

		// 执行循环体
		result = e.Eval(wl.Body)
		if isError(result) {
			e.env = outerEnv // 恢复环境
			return result
		}

		// 检查是否有返回值、break或continue
		if result != nil && result.Type() == RETURN_VALUE_OBJ {
			e.env = outerEnv // 恢复环境
			return result    // 保留ReturnValue的包装，让外层函数处理
		}

		// 如果遇到break，跳出循环
		if result != nil && result.Type() == BREAK_OBJ {
			break // 只跳出循环，不立即返回
		}

		// 如果遇到continue，直接进入下一次循环
		if result != nil && result.Type() == CONTINUE_OBJ {
			continue // 进入下一次循环
		}
	}

	// 将循环环境中的变量复制回外部环境
	for name, val := range loopEnv.store {
		outerEnv.Set(name, val)
	}

	// 恢复原始环境
	e.env = outerEnv

	return UNDEFINED
}

// evalBreakStatement 解释执行break语句
func (e *Evaluator) evalBreakStatement() Object {
	return &Break{}
}

// evalContinueStatement 解释执行continue语句
func (e *Evaluator) evalContinueStatement() Object {
	return &Continue{}
}

// registerBuiltins 注册内置函数
func (e *Evaluator) registerBuiltins() {

	// console
	e.registerConsole()

	// 注册全局函数
	globalBuiltins := map[string]BuiltinFunction{
		"parseInt": func(args ...Object) Object {
			if len(args) < 1 {
				return newError("parseInt 需要至少一个参数")
			}

			str, ok := args[0].(*String)
			if !ok {
				// 自动转换为字符串
				str = &String{Value: args[0].Inspect()}
			}

			radix := 10
			if len(args) > 1 {
				if radixObj, ok := args[1].(*Integer); ok {
					radix = int(radixObj.Value)
				}
			}

			val, err := strconv.ParseInt(str.Value, radix, 64)
			if err != nil {
				return &Integer{Value: 0} // JavaScript中，解析失败返回NaN，这里简化为0
			}

			return &Integer{Value: val}
		},
		"parseFloat": func(args ...Object) Object {
			if len(args) < 1 {
				return newError("parseFloat 需要至少一个参数")
			}

			str, ok := args[0].(*String)
			if !ok {
				// 自动转换为字符串
				str = &String{Value: args[0].Inspect()}
			}

			val, err := strconv.ParseFloat(str.Value, 64)
			if err != nil {
				return &Float{Value: 0.0} // JavaScript中，解析失败返回NaN
			}

			return &Float{Value: val}
		},
		"isNaN": func(args ...Object) Object {
			if len(args) < 1 {
				return TRUE // isNaN()返回true
			}

			var val float64
			switch arg := args[0].(type) {
			case *Integer:
				val = float64(arg.Value)
				return FALSE // 整数永远不是NaN
			case *Float:
				val = arg.Value
				return nativeBoolToBooleanObject(math.IsNaN(val))
			case *String:
				// 尝试将字符串转换为数字
				f, err := strconv.ParseFloat(arg.Value, 64)
				if err != nil {
					return TRUE // 不能转换为数字的字符串被认为是NaN
				}
				return nativeBoolToBooleanObject(math.IsNaN(f))
			case *Boolean:
				return FALSE // 布尔值可以转换为数字
			case *Null:
				return FALSE // null转换为0
			case *Undefined:
				return TRUE // undefined被认为是NaN
			default:
				return TRUE // 其他类型被认为是NaN
			}
		},
		"eval": func(args ...Object) Object {
			// 确保至少有一个参数
			if len(args) < 1 {
				return newError("eval 需要一个字符串参数")
			}

			// 获取字符串参数
			str, ok := args[0].(*String)
			if !ok {
				// 尝试转换为字符串
				str = &String{Value: args[0].Inspect()}
			}

			// 解析字符串为AST
			l := lexer.New(str.Value)
			p := parser.New(l)
			program := p.ParseProgram()

			if len(p.Errors()) > 0 {
				return newError("解析错误: %v", p.Errors())
			}

			// 使用当前环境评估AST
			return e.Eval(program)
		},
	}

	// 将全局函数添加到builtins映射
	for name, fn := range globalBuiltins {
		e.builtins[name] = &Builtin{Fn: fn}
	}

	// 创建Object全局对象和原型
	objectProto := &Hash{
		Pairs:   make(map[HashKey]HashPair),
		Methods: make(map[string]Object),
	}

	// 添加Object.prototype.toString方法
	toStringFn := &Builtin{
		Fn: func(args ...Object) Object {
			// 安全检查参数
			if len(args) == 0 {
				return &String{Value: "[object Object]"}
			}

			// 获取目标对象（第一个参数是this）
			obj := args[0]
			if obj == nil {
				return &String{Value: "null"}
			}

			switch obj := obj.(type) {
			case *Hash:
				return &String{Value: "[object Object]"}
			case *Array:
				return &String{Value: obj.Inspect()}
			case *String:
				return obj
			case *Integer:
				return &String{Value: obj.Inspect()}
			case *Float:
				return &String{Value: obj.Inspect()}
			case *Boolean:
				return &String{Value: obj.Inspect()}
			default:
				return &String{Value: fmt.Sprintf("[object %s]", obj.Type())}
			}
		},
	}
	strKey := &String{Value: "toString"}
	objectProto.Methods["toString"] = toStringFn
	objectProto.Pairs[strKey.HashKey()] = HashPair{Key: strKey, Value: toStringFn}

	// 创建Object构造函数
	objConstructor := &Builtin{
		Fn: func(args ...Object) Object {
			if len(args) > 0 {
				// 如果传入了参数，返回该对象
				return args[0]
			}
			// 创建空对象
			return &Hash{
				Pairs:     make(map[HashKey]HashPair),
				Methods:   make(map[string]Object),
				Prototype: objectProto,
			}
		},
	}

	// 创建Object对象包装
	objWrapper := &Hash{
		Pairs:   make(map[HashKey]HashPair),
		Methods: make(map[string]Object),
	}

	// 添加Object.keys方法
	keysMethod := &Builtin{
		Fn: func(args ...Object) Object {
			if len(args) < 1 {
				return newError("Object.keys: 需要1个参数，得到0个")
			}

			obj, ok := args[0].(*Hash)
			if !ok {
				return newError("Object.keys: 参数必须是对象")
			}

			keys := &Array{Elements: []Object{}}
			for _, pair := range obj.Pairs {
				keys.Elements = append(keys.Elements, pair.Key)
			}

			return keys
		},
	}

	// 设置Object对象属性
	protoKey := &String{Value: "prototype"}
	objWrapper.Pairs[protoKey.HashKey()] = HashPair{Key: protoKey, Value: objectProto}

	keysKey := &String{Value: "keys"}
	objWrapper.Pairs[keysKey.HashKey()] = HashPair{Key: keysKey, Value: keysMethod}

	// 将Object函数设置为默认执行函数
	objWrapper.Methods["_function"] = objConstructor

	// 将Object设置为全局对象
	e.env.Set("Object", objWrapper)
}

// 辅助函数

// nativeBoolToBooleanObject 将Go布尔值转换为对象
func nativeBoolToBooleanObject(input bool) *Boolean {
	if input {
		return TRUE
	}
	return FALSE
}

// isTruthy 检查对象是否为真值
func isTruthy(obj Object) bool {
	switch obj {
	case NULL:
		return false
	case UNDEFINED:
		return false
	case TRUE:
		return true
	case FALSE:
		return false
	default:
		switch obj.Type() {
		case INTEGER_OBJ:
			return obj.(*Integer).Value != 0
		case FLOAT_OBJ:
			return obj.(*Float).Value != 0
		case STRING_OBJ:
			return obj.(*String).Value != ""
		default:
			return true
		}
	}
}

// isError 检查对象是否为错误
func isError(obj Object) bool {
	if obj != nil {
		return obj.Type() == ERROR_OBJ
	}
	return false
}

// newError 创建一个新的错误对象
func newError(format string, a ...interface{}) *Error {
	return &Error{Message: fmt.Sprintf(format, a...)}
}

// evalClassDeclaration 解释执行类声明
func (e *Evaluator) evalClassDeclaration(node *ast.ClassDeclaration) Object {
	// 创建Class对象
	class := &Class{
		Name:       node.Name.Value,
		Properties: make(map[string]Object),
		Methods:    make(map[string]Object),
		Prototype:  &Hash{Pairs: make(map[HashKey]HashPair), Methods: make(map[string]Object)},
	}

	// 处理继承
	if node.SuperClass != nil {
		superClassObj := e.evalIdentifier(node.SuperClass)
		if isError(superClassObj) {
			return superClassObj
		}

		superClass, ok := superClassObj.(*Class)
		if !ok {
			return newError("父类不是一个有效的类: %s", superClassObj.Type())
		}

		// 继承原型链
		class.Prototype.Prototype = superClass.Prototype

		// 继承父类实例属性 - 添加父类引用到原型中
		// 使用特殊键存储父类引用
		parentClassKey := &String{Value: "__parent_class__"}
		parentClassHashKey := parentClassKey.HashKey()
		class.Prototype.Pairs[parentClassHashKey] = HashPair{Key: parentClassKey, Value: superClass}

		// 复制父类属性到子类原型
		for key, pair := range superClass.Prototype.Pairs {
			// 不复制特殊属性
			if s, ok := pair.Key.(*String); ok && s.Value == "__parent_class__" {
				continue
			}
			class.Prototype.Pairs[key] = pair
		}

		// 继承方法
		for name, method := range superClass.Methods {
			class.Methods[name] = method
		}

		// 继承原型方法
		for name, method := range superClass.Prototype.Methods {
			class.Prototype.Methods[name] = method
		}
	}

	// 处理类体
	if node.Body != nil {
		// 处理属性
		for _, prop := range node.Body.Properties {
			var value Object = UNDEFINED
			if prop.Value != nil {
				value = e.Eval(prop.Value)
				if isError(value) {
					return value
				}
			}

			if prop.IsStatic {
				class.Properties[prop.Name.Value] = value
			} else {
				// 实例属性定义在原型上
				propKey := &String{Value: prop.Name.Value}
				hashKey := propKey.HashKey()
				class.Prototype.Pairs[hashKey] = HashPair{Key: propKey, Value: value}
			}
		}

		// 处理方法
		for _, method := range node.Body.Methods {
			// 创建方法函数
			fn := &Function{
				Parameters: method.Params,
				Body:       method.Body,
				Env:        e.env,
				Name:       method.Name.Value,
			}

			// 处理构造函数
			if method.Name.Value == "constructor" {
				class.Constructor = fn
			} else if method.IsStatic {
				// 静态方法
				class.Methods[method.Name.Value] = fn
			} else {
				// 实例方法
				class.Prototype.Methods[method.Name.Value] = fn
			}
		}
	}

	// 如果没有定义构造函数，创建默认构造函数
	if class.Constructor == nil {
		class.Constructor = &Function{
			Parameters: []*ast.Identifier{},
			Body:       &ast.BlockStatement{Statements: []ast.Statement{}},
			Env:        e.env,
			Name:       "constructor",
		}
	}

	// 将类存储在环境中
	e.env.Set(node.Name.Value, class)

	return class
}

// evalClassExpression 解释执行类表达式
func (e *Evaluator) evalClassExpression(node *ast.ClassExpression) Object {
	// 创建Class对象
	class := &Class{
		Properties: make(map[string]Object),
		Methods:    make(map[string]Object),
		Prototype:  &Hash{Pairs: make(map[HashKey]HashPair), Methods: make(map[string]Object)},
	}

	// 设置类名（如果有）
	if node.Name != nil {
		class.Name = node.Name.Value
	} else {
		class.Name = "AnonymousClass"
	}

	// 处理继承（与类声明相同的逻辑）
	if node.SuperClass != nil {
		superClassObj := e.evalIdentifier(node.SuperClass)
		if isError(superClassObj) {
			return superClassObj
		}

		superClass, ok := superClassObj.(*Class)
		if !ok {
			return newError("父类不是一个有效的类: %s", superClassObj.Type())
		}

		// 继承原型链
		class.Prototype.Prototype = superClass.Prototype

		// 继承父类实例属性 - 添加父类引用到原型中
		// 使用特殊键存储父类引用
		parentClassKey := &String{Value: "__parent_class__"}
		parentClassHashKey := parentClassKey.HashKey()
		class.Prototype.Pairs[parentClassHashKey] = HashPair{Key: parentClassKey, Value: superClass}

		// 复制父类属性到子类原型
		for key, pair := range superClass.Prototype.Pairs {
			// 不复制特殊属性
			if s, ok := pair.Key.(*String); ok && s.Value == "__parent_class__" {
				continue
			}
			class.Prototype.Pairs[key] = pair
		}

		// 继承方法
		for name, method := range superClass.Methods {
			class.Methods[name] = method
		}

		// 继承原型方法
		for name, method := range superClass.Prototype.Methods {
			class.Prototype.Methods[name] = method
		}
	}

	// 处理类体（与类声明相同的逻辑）
	if node.Body != nil {
		// 处理属性
		for _, prop := range node.Body.Properties {
			var value Object = UNDEFINED
			if prop.Value != nil {
				value = e.Eval(prop.Value)
				if isError(value) {
					return value
				}
			}

			if prop.IsStatic {
				class.Properties[prop.Name.Value] = value
			} else {
				// 实例属性定义在原型上
				propKey := &String{Value: prop.Name.Value}
				hashKey := propKey.HashKey()
				class.Prototype.Pairs[hashKey] = HashPair{Key: propKey, Value: value}
			}
		}

		// 处理方法
		for _, method := range node.Body.Methods {
			// 创建方法函数
			fn := &Function{
				Parameters: method.Params,
				Body:       method.Body,
				Env:        e.env,
				Name:       method.Name.Value,
			}

			// 处理构造函数
			if method.Name.Value == "constructor" {
				class.Constructor = fn
			} else if method.IsStatic {
				// 静态方法
				class.Methods[method.Name.Value] = fn
			} else {
				// 实例方法
				class.Prototype.Methods[method.Name.Value] = fn
			}
		}
	}

	// 如果没有定义构造函数，创建默认构造函数
	if class.Constructor == nil {
		class.Constructor = &Function{
			Parameters: []*ast.Identifier{},
			Body:       &ast.BlockStatement{Statements: []ast.Statement{}},
			Env:        e.env,
			Name:       "constructor",
		}
	}

	return class
}

// evalNewExpression 解释执行new表达式
func (e *Evaluator) evalNewExpression(node *ast.NewExpression) Object {
	constructor := e.Eval(node.Constructor)
	if isError(constructor) {
		return constructor
	}

	args := e.evalExpressions(node.Arguments)
	if len(args) == 1 && isError(args[0]) {
		return args[0]
	}

	switch constructor := constructor.(type) {
	case *Class:
		// 创建类实例
		instance := &ClassInstance{
			Class:      constructor,
			Properties: make(map[HashKey]HashPair),
		}

		// 如果有构造函数，调用它
		if constructor.Constructor != nil {
			// 创建构造函数环境并传递参数
			env := extendFunctionEnv(constructor.Constructor, args)
			env.Set("this", instance) // 设置this为当前实例

			// 保存当前环境
			oldEnv := e.env
			// 设置新环境
			e.env = env

			// 记录属性数量
			oldPropsCount := len(instance.Properties)

			// 执行构造函数
			e.Eval(constructor.Constructor.Body)

			// 如果构造函数没有设置任何属性，尝试根据参数名称自动设置
			if len(instance.Properties) == oldPropsCount {
				// 自动将构造函数参数映射到同名属性
				for i, param := range constructor.Constructor.Parameters {
					if i < len(args) {
						// 创建属性键
						propKey := &String{Value: param.Value}
						hashKey := propKey.HashKey()
						// 设置属性值
						instance.Properties[hashKey] = HashPair{Key: propKey, Value: args[i]}
					}
				}
			}

			// 恢复环境
			e.env = oldEnv
		}

		return instance
	default:
		return newError("构造函数必须是一个类: %s", constructor.Type())
	}
}

// evalSwitchStatement 评估switch语句
func (e *Evaluator) evalSwitchStatement(ss *ast.SwitchStatement) Object {
	// 记录当前节点
	previousNode := e.currentNode
	e.currentNode = ss
	defer func() { e.currentNode = previousNode }()

	// 评估switch的条件表达式
	switchValue := e.Eval(ss.Value)
	if isError(switchValue) {
		return switchValue
	}

	// 标记是否已经找到匹配的case
	foundMatch := false
	// 最后一次执行case的结果
	var lastResult Object = NULL

	// 遍历所有case语句
	for _, caseStmt := range ss.Cases {
		// 跳过默认情况，稍后处理
		if caseStmt.IsDefault {
			continue
		}

		// 如果已经找到匹配项，则直接执行（穿透行为）
		if foundMatch {
			// 执行case语句块
			result := e.Eval(caseStmt.Consequence)
			lastResult = result

			// 处理特殊情况
			if isError(result) {
				return result
			}

			// 检查是否有break语句
			if _, ok := result.(*Break); ok {
				return NULL // 遇到break，终止switch
			}

			// 检查是否是return语句
			if returnVal, ok := result.(*ReturnValue); ok {
				return returnVal
			}

			// 继续穿透到下一个case
			continue
		}

		// 如果还没找到匹配项，评估case条件
		// 评估case条件表达式
		caseValue := e.Eval(caseStmt.Condition)
		if isError(caseValue) {
			return caseValue
		}

		// 比较switch值和case值是否相等
		equal := false

		// 先尝试严格相等比较（===），确保类型和值都相同
		if switchValue.Type() == caseValue.Type() {
			switch switchValue.Type() {
			case INTEGER_OBJ:
				equal = switchValue.(*Integer).Value == caseValue.(*Integer).Value
			case FLOAT_OBJ:
				equal = switchValue.(*Float).Value == caseValue.(*Float).Value
			case BOOLEAN_OBJ:
				equal = switchValue.(*Boolean).Value == caseValue.(*Boolean).Value
			case STRING_OBJ:
				equal = switchValue.(*String).Value == caseValue.(*String).Value
			case NULL_OBJ:
				equal = true
			case UNDEFINED_OBJ:
				equal = true
			case ARRAY_OBJ:
				// 数组引用比较
				equal = switchValue == caseValue
			case OBJECT_OBJ:
				// 对象引用比较
				equal = switchValue == caseValue
			case FUNCTION_OBJ:
				// 函数引用比较
				equal = switchValue == caseValue
			default:
				// 其他类型的引用比较
				equal = switchValue == caseValue
			}
		} else {
			// JS中的switch使用的是严格相等比较（===），而不是松散相等（==）
			// 在此仅支持一些必要的转换

			// 对于布尔类型和数字类型的特殊处理，确保true不匹配1
			// 这在标准JavaScript中不会发生，但我们在这里显式防止它
			if switchValue.Type() == BOOLEAN_OBJ && caseValue.Type() == INTEGER_OBJ {
				// 布尔值不应与数字匹配
				equal = false
			} else if switchValue.Type() == INTEGER_OBJ && caseValue.Type() == BOOLEAN_OBJ {
				// 数字不应与布尔值匹配
				equal = false
			} else if (switchValue.Type() == INTEGER_OBJ || switchValue.Type() == FLOAT_OBJ) &&
				caseValue.Type() == STRING_OBJ {
				// 尝试将字符串转为数字进行比较
				strVal := caseValue.(*String).Value
				if switchValue.Type() == INTEGER_OBJ {
					if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
						equal = switchValue.(*Integer).Value == intVal
					}
				} else { // FLOAT_OBJ
					if floatVal, err := strconv.ParseFloat(strVal, 64); err == nil {
						equal = switchValue.(*Float).Value == floatVal
					}
				}
			} else if switchValue.Type() == STRING_OBJ &&
				(caseValue.Type() == INTEGER_OBJ || caseValue.Type() == FLOAT_OBJ) {
				// 尝试将字符串转为数字进行比较
				strVal := switchValue.(*String).Value
				if caseValue.Type() == INTEGER_OBJ {
					if intVal, err := strconv.ParseInt(strVal, 10, 64); err == nil {
						equal = intVal == caseValue.(*Integer).Value
					}
				} else { // FLOAT_OBJ
					if floatVal, err := strconv.ParseFloat(strVal, 64); err == nil {
						equal = floatVal == caseValue.(*Float).Value
					}
				}
			}
		}

		if equal {
			// 找到匹配项
			foundMatch = true

			// 执行case语句块
			result := e.Eval(caseStmt.Consequence)
			lastResult = result

			// 处理特殊情况
			if isError(result) {
				return result
			}

			// 检查是否有break语句
			if _, ok := result.(*Break); ok {
				return NULL // 遇到break，终止switch
			}

			// 检查是否是return语句
			if returnVal, ok := result.(*ReturnValue); ok {
				return returnVal
			}
		}
	}

	// 如果没有找到匹配项，检查是否有default（可能来自Cases数组或Default字段）
	if !foundMatch {
		// 首先检查在Cases数组中的default case
		for _, caseStmt := range ss.Cases {
			if caseStmt.IsDefault {
				result := e.Eval(caseStmt.Consequence)

				// 处理特殊情况
				if isError(result) {
					return result
				}

				if _, ok := result.(*Break); ok {
					return NULL
				}

				if returnVal, ok := result.(*ReturnValue); ok {
					return returnVal
				}

				return result
			}
		}

		// 然后检查Default字段
		if ss.Default != nil {
			result := e.Eval(ss.Default.Consequence)

			// 处理特殊情况
			if isError(result) {
				return result
			}

			if _, ok := result.(*Break); ok {
				return NULL
			}

			if returnVal, ok := result.(*ReturnValue); ok {
				return returnVal
			}

			return result
		}
	}

	// 返回最后一次执行的结果
	return lastResult
}

// evalPostfixExpression 评估后缀表达式
func (e *Evaluator) evalPostfixExpression(operator string, left Object, node ast.Expression) Object {
	fmt.Println("注意: 后缀表达式功能尚未完全实现")
	return newError("后缀表达式尚未完全实现")
}

// evalCompoundAssignExpression 评估复合赋值表达式
func (e *Evaluator) evalCompoundAssignExpression(node *ast.CompoundAssignExpression) Object {
	fmt.Println("注意: 复合赋值表达式功能尚未完全实现")
	return newError("复合赋值表达式(%s %s)尚未实现", node.Left.String(), node.Operator)
}

// evalThisExpression 评估this表达式
func (e *Evaluator) evalThisExpression() Object {
	fmt.Println("注意: this表达式功能尚未完全实现")
	return newError("this表达式尚未实现")
}

// evalSuperExpression 评估super表达式
func (e *Evaluator) evalSuperExpression(node *ast.SuperExpression) Object {
	fmt.Println("注意: super表达式功能尚未完全实现")
	return newError("super表达式尚未实现")
}

// evalTryStatement 评估try语句
func (e *Evaluator) evalTryStatement(node *ast.TryStatement) Object {
	fmt.Println("注意: try语句功能尚未完全实现")
	return newError("try语句尚未实现")
}

// evalThrowStatement 评估throw语句
func (e *Evaluator) evalThrowStatement(node *ast.ThrowStatement) Object {
	fmt.Println("注意: throw语句功能尚未完全实现")
	return newError("throw语句尚未实现")
}

// evalTemplateLiteral 评估模板字符串
func (e *Evaluator) evalTemplateLiteral(node *ast.TemplateLiteral) Object {
	// 首先获取模板字符串的原始内容
	input := node.Quasis[0]

	// 使用基本的字符串解析查找${...}模式并替换
	var result strings.Builder
	i := 0

	for i < len(input) {
		// 查找 ${ 开始的位置
		start := strings.Index(input[i:], "${")
		if start == -1 {
			// 没有找到更多的 ${，添加剩余部分并结束
			result.WriteString(input[i:])
			break
		}

		// 添加前缀
		result.WriteString(input[i : i+start])
		i += start + 2 // 跳过 "${"

		// 查找匹配的 }
		braceCount := 1
		exprStart := i
		for i < len(input) && braceCount > 0 {
			if input[i] == '}' {
				braceCount--
			} else if input[i] == '{' {
				braceCount++
			}
			i++
		}

		if braceCount > 0 {
			// 未找到匹配的 }，保留原始字符串
			result.WriteString("${")
			i = exprStart
			continue
		}

		// 获取表达式
		exprStr := input[exprStart : i-1]

		// 尝试从环境中查找变量
		if obj, ok := e.env.Get(exprStr); ok {
			result.WriteString(obj.Inspect())
		} else {
			// 找不到变量，使用eval函数尝试计算表达式

			// 使用内置的eval解析表达式
			// 注意：我们使用自己的builtins中的eval函数，而不是直接导入parser
			evalFn := e.builtins["eval"]
			// 创建字符串对象
			exprObj := &String{Value: exprStr}
			// 调用eval函数
			evalResult := evalFn.Fn(exprObj)
			if isError(evalResult) {
				// 如果计算出错，保留原始表达式
				result.WriteString("${" + exprStr + "}")
			} else {
				// 添加计算结果
				result.WriteString(evalResult.Inspect())
			}
		}
	}

	return &String{Value: result.String()}
}
